import fs from 'fs';
import path from 'path';
import { parse } from '@babel/parser';
import traverse from '@babel/traverse';

// 配置扫描路径
const SRC_DIR = './src';
const TRANSLATION_FILES = {
  en: './src/i18n/locales/en/translation.json',
  zh: './src/i18n/locales/zh/translation.json'
};

// 需要排除的文件或目录
const EXCLUDE_PATHS = [
  'node_modules',
  'i18n',
  'routeTree.gen.ts'
];

// 需要扫描的文件扩展名
const FILE_EXTENSIONS = ['.ts', '.tsx'];

// 已存在的翻译键值
let existingTranslations = {};

// 扫描到的硬编码文本
let extractedStrings = new Map();

// 检查是否应该排除该路径
function shouldExclude(filePath) {
  return EXCLUDE_PATHS.some(exclude => filePath.includes(exclude));
}

// 生成翻译键
function generateKey(file, text) {
  // 根据文件路径和文本内容生成键名
  const relativePath = path.relative(SRC_DIR, file);
  const dir = path.dirname(relativePath);
  const fileName = path.basename(relativePath, path.extname(relativePath));
  
  // 清理文本，移除特殊字符
  const cleanText = text
    .replace(/[^a-zA-Z0-9\s]/g, '')
    .replace(/\s+/g, ' ')
    .trim()
    .replace(/\s/g, '');
    
  // 生成键名
  let key = dir.replace(/\//g, '.').replace(/\\/g, '.');
  if (key) key += '.';
  key += `${fileName}.${cleanText}`;
  
  return key.toLowerCase();
}

// 提取 JSX 文本节点
function extractJSXText(node, file) {
  if (node.type === 'JSXText' && node.value.trim()) {
    const text = node.value.trim();
    // 过滤掉太短或可能是代码的文本
    if (text.length > 2 && !/^[0-9\s]+$/.test(text)) {
      const key = generateKey(file, text);
      extractedStrings.set(key, {
        text,
        file,
        loc: node.loc
      });
    }
  }
}

// 提取模板字符串中的文本
function extractTemplateLiteral(node, file) {
  node.expressions.forEach(expr => {
    if (expr.type === 'StringLiteral' && expr.value.trim()) {
      const text = expr.value.trim();
      if (text.length > 2) {
        const key = generateKey(file, text);
        extractedStrings.set(key, {
          text,
          file,
          loc: expr.loc
        });
      }
    }
  });
}

// 解析单个文件
function parseFile(file) {
  try {
    const code = fs.readFileSync(file, 'utf-8');
    const ast = parse(code, {
      sourceType: 'module',
      plugins: [
        'typescript',
        'jsx',
        'decorators-legacy',
        'classProperties'
      ]
    });

    traverse.default(ast, {
      JSXText(path) {
        extractJSXText(path.node, file);
      },
      TemplateLiteral(path) {
        extractTemplateLiteral(path.node, file);
      }
    });
  } catch (error) {
    console.error(`Error parsing file ${file}:`, error.message);
  }
}

// 递归扫描目录
function scanDirectory(dir) {
  const files = fs.readdirSync(dir);
  
  files.forEach(file => {
    const filePath = path.join(dir, file);
    const stat = fs.statSync(filePath);
    
    if (stat.isDirectory()) {
      scanDirectory(filePath);
    } else if (stat.isFile() && FILE_EXTENSIONS.includes(path.extname(filePath))) {
      if (!shouldExclude(filePath)) {
        parseFile(filePath);
      }
    }
  });
}

// 更新翻译文件
function updateTranslationFiles() {
  // 读取现有翻译
  Object.keys(TRANSLATION_FILES).forEach(lang => {
    if (fs.existsSync(TRANSLATION_FILES[lang])) {
      const content = fs.readFileSync(TRANSLATION_FILES[lang], 'utf-8');
      existingTranslations[lang] = JSON.parse(content);
    } else {
      existingTranslations[lang] = {};
    }
  });

  // 更新翻译文件
  Object.keys(TRANSLATION_FILES).forEach(lang => {
    // 合并新提取的键值
    extractedStrings.forEach((value, key) => {
      if (!existingTranslations[lang][key]) {
        // 对于中文，可以使用在线翻译API或者手动翻译
        existingTranslations[lang][key] = lang === 'en' ? value.text : `【待翻译】${value.text}`;
      }
    });

    // 保存文件
    fs.writeFileSync(TRANSLATION_FILES[lang], JSON.stringify(existingTranslations[lang], null, 2));
    console.log(`Updated ${TRANSLATION_FILES[lang]}`);
  });
}

// 主函数
function main() {
  console.log('Starting i18n auto-extraction...');
  
  // 扫描源代码目录
  scanDirectory(SRC_DIR);
  
  console.log(`Found ${extractedStrings.size} strings to translate`);
  
  // 更新翻译文件
  updateTranslationFiles();
  
  // 输出报告
  console.log('\nExtraction report:');
  extractedStrings.forEach((value, key) => {
    console.log(`${key}: ${value.text} (${value.file}:${value.loc.start.line})`);
  });
  
  console.log('\nDone!');
}

// 运行主函数
main();